package tge

// 协议解析器
type ProtoParser interface {
	Unmarshal(data []byte) (uint16, interface{}, error)
	Marshal(msg interface{}) ([]byte, error)
}

// 消息包
type MsgPack struct {
	Msg 	interface{} // 解析后的数据结构
	Buf		[]byte 		// 原始消息数据
}

// 路由接口声明
type Route interface {
	Route(id uint16, msg interface{}, userData interface{}) error
}

type Handler struct {
	fn 		[]func(interface{}, interface{})
}

// 消息路由处理器
type Router struct {
	filters	[]func(interface{}, interface{})bool 	// 过滤器
	normal	*Handler	// 通用回调
	handlers	map[uint16]*Handler
}

func NewRoute()*Router {
	return &Router{make([]func(interface{}, interface{})bool, 0, 1), new(Handler), make(map[uint16]*Handler)}
}

// 添加过滤器，如果过滤器返回 false 则不再派发消息
func (p *Router) AddFilter(fn func(interface{}, interface{})bool) {
	p.filters = append(p.filters, fn)
}

// 注册响应函数，如果 id 为 0 则表示所有消息都要响应
func (p *Router) Register(id uint16, fn func(interface{}, interface{})) {
	if 0 == id {
		p.normal.fn = append(p.normal.fn, fn)
	} else if h, ok := p.handlers[id]; ok {
		h.fn = append(h.fn, fn)
	} else {
		h := new(Handler)
		h.fn = append(h.fn, fn)
		p.handlers[id] = h
	}
}

// 分发消息
func (p *Router) Route(id uint16, msg interface{}, userData interface{}) error {
	for _, fn := range p.filters {
		if !fn(msg, userData) {
			return nil
		}
	}
	for _, fn := range p.normal.fn {
		fn(msg, userData)
	}
	if h, ok := p.handlers[id]; ok {
		for _, fn := range h.fn {
			fn(msg, userData)
		}
	}
	return nil
}